package 注解;

//《概述》
//AnnotatedType表示当前程序中可能被注解的类型。 这些类型可能是Java编程语言中的任何Type，包括Class（原始类型）、ParameterizedType（参数化的类
//型、泛型类型）、TypeVariable（类型变量）、WildcardType（通配符类型）、GenericArrayType（泛型数组类型）这五种java中的具体类型。而AnnotatedType对
//这些类型作了一层包装，因为这些类型都是可能被注解的。同时AnnotatedType继承了AnnotatedElement使得我们能够在运行时基于反射api去分析获取那些十分复杂的数据结构中的注解。
//
//【AnnotatedType】
//我们先来看一下AnnotatedType的定义：
//
//package java.lang.reflect;
//
//public interface AnnotatedType extends AnnotatedElement {
//    
//    public Type getType();
//}
//
//可以发现AnnotatedType继承了我们在上篇文章中介绍的AnnotatedElement，也就是说通过AnnotatedType我们就能获取该类型的元素上的所有注解。同时类中定义
//了一个getType方法，这个方法的返回值则代表了运行时的对象的Type，可能是Class、ParameterizedType、TypeVariable、WildcardType、GenericArrayType
//中的任何一种。所以我们可以把AnnotatedType当做的Type的一种加强类型，通过这种类型我们就能基于反射获取元素上的所有注解。下面我们来看一下它的子接口一共有几种：
//
//AnnotatedElement-->AnnotatedType-->AnnotatedParameterizedType（被注解的参数化类型）
//                                -->AnnotatedTypeVariable（被注解的类型变量）
//                                -->AnnotatedWildcardType（被注解的通配符类型）
//                                --AnnotatedArrayType（被注解的数组类型）
//                                -->AnnotatedTypeBaseImpl（被注解的基础类型（除了以上四种类型以外的其它类型））
//
//
//
//通过上面的类图我们可以发现一共有五种类型继承或者实现了AnnotatedType接口，它们分别代表AnnotatedParameterizedType（被注解的参数化类型）、
//AnnotatedTypeVariable（被注解的类型变量）、AnnotatedWildcardType（被注解的通配符类型）、AnnotatedArrayType（被注解的数组类型）、
//AnnotatedTypeBaseImpl（被注解的基础类型（除了以上四种类型以外的其它类型）），下面我们一一介绍这五种类型的具体含义。
//
//《AnnotatedParameterizedType》
//AnnotatedParameterizedType是指那些可能带注解的ParameterizedType类型的数据，例如List<String> list是一个ParameterizedType，同时也是一
//个AnnotatedParameterizedType，只不过此时它本身没有带注解而已，当然啦，它的类型参数<String>也是有可能带注解的任何AnnotatedType，所
//以AnnotatedParameterizedType提供了getAnnotatedActualTypeArguments方法来获取带注解的类型参数。
//
//package java.lang.reflect;
//
//public interface AnnotatedParameterizedType extends AnnotatedType {
//
//    AnnotatedType[] getAnnotatedActualTypeArguments();
//}
//
//下面看一个例子：

/*
import java.lang.annotation.*;
import java.lang.reflect.AnnotatedParameterizedType;
import java.util.Arrays;
import java.util.List;
//public class AnnotatedParameterizedTypeTest {
public class AnnotatedType类 {

    public List<@MyAnnotation(value=5) String> list1;//list1中的每一 String 项的注解为MyAnnotation,括符内为value的值。

    public List<@MyAnnotation(2) List<@MyAnnotation(3) String>> list2;//嵌套List -> List<List<String>>,都使用注解

    public static void main(String[] args) {
        Arrays.stream(AnnotatedType类.class.getDeclaredFields()).forEach
        (field -> print((AnnotatedParameterizedType) field.getAnnotatedType()));
    }

    private static void print(AnnotatedParameterizedType annotatedParameterizedType) {
        Arrays.stream(annotatedParameterizedType.getAnnotatedActualTypeArguments())
                .forEach(annotatedType -> {
                            System.out.println(Arrays.toString(annotatedType.getDeclaredAnnotations()));
                            if (annotatedType instanceof AnnotatedParameterizedType) {
                                print((AnnotatedParameterizedType) annotatedType);
                            }
                        }
                );
    }

    @Target({ElementType.FIELD, ElementType.TYPE_USE, ElementType.TYPE, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyAnnotation {
        int value();
    }
}
*/
//控制台输出
//
//[@com.zyc.AnnotatedParameterizedTypeTest$MyAnnotation(value=1)]
//[@com.zyc.AnnotatedParameterizedTypeTest$MyAnnotation(value=2)]
//[@com.zyc.AnnotatedParameterizedTypeTest$MyAnnotation(value=3)]
//在上面的例子中定义两个ParameterizedType的域，然后通过Field的getAnnotatedType方法获取其对应的AnnotatedType，也就是AnnotatedParameterizedType，
//然后递归打印类型参数上的注解。
//
//【AnnotatedTypeVariable】
//AnnotatedTypeVariable是指那些可能带注解的TypeVariable类型的数据，例如T t是一个TypeVariable类型的值，同时也是一个AnnotatedTypeVariable类型的值，只不过此时它
//本身没有带注解而已，当然啦，它的类型变量本身是带边界的，所以它的所有边界都有可能是带注解的任何AnnotatedType，所以AnnotatedTypeVariable提供了getAnnotatedBounds方
//法来获取所有带注解的边界。
//
//package java.lang.reflect;
//
//public interface AnnotatedTypeVariable extends AnnotatedType {
//
//    AnnotatedType[] getAnnotatedBounds();
//}
//下面看一个例子：
/*
import java.io.Serializable;
import java.lang.annotation.*;
import java.lang.reflect.AnnotatedTypeVariable;
import java.util.Arrays;

//public class AnnotatedTypeVariableTest<T extends @MyAnnotation(1) Number & @MyAnnotation(2) Cloneable & @MyAnnotation(3) Serializable> {
public class AnnotatedType类<T extends Number & @MyAnnotation(2) Cloneable & @MyAnnotation(3) Serializable> {
//public class AnnotatedType类<T extends @MyAnnotation(1) Number & @MyAnnotation(2) Cloneable & @MyAnnotation(3) Serializable> {

    public T t;

    public static void main(String[] args) throws Exception {
        AnnotatedTypeVariable annotatedTypeVariable = (AnnotatedTypeVariable) AnnotatedType类.class.getDeclaredField("t").getAnnotatedType();
        Arrays.stream(annotatedTypeVariable.getAnnotatedBounds()).forEach(annotatedType -> System.out.println(Arrays.toString(annotatedType.getDeclaredAnnotations())));
    }

    @Target({ElementType.FIELD, ElementType.TYPE_USE, ElementType.TYPE, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyAnnotation {
        int value();
    }
}
*/
//控制台输出
//
//[@com.zyc.AnnotatedTypeVariableTest$MyAnnotation(value=1)]
//[@com.zyc.AnnotatedTypeVariableTest$MyAnnotation(value=2)]
//[@com.zyc.AnnotatedTypeVariableTest$MyAnnotation(value=3)]
//在上面的例子中定义了一个TypeVariable类型的域t，然后通过反射获取该域的AnnotatedType，也就是AnnotatedTypeVariable，然后通过AnnotatedTypeVariable提供
//的getAnnotatedBounds方法获取T的所有AnnotatedType边界，最后打印所有边界上的注解。
//
//【AnnotatedWildcardType】
//AnnotatedWildcardType是指那些可能带注解的WildcardType类型的数据，当然其上限或下限本身可能也是带注解的类型。
//
//package java.lang.reflect;
//
//public interface AnnotatedWildcardType extends AnnotatedType {
//	
//    AnnotatedType[] getAnnotatedLowerBounds();
//
//    AnnotatedType[] getAnnotatedUpperBounds();
//}
//下面看一个例子：
//
import java.lang.annotation.*;
import java.lang.reflect.AnnotatedParameterizedType;
import java.lang.reflect.AnnotatedWildcardType;
import java.util.Arrays;
import java.util.List;

//public class AnnotatedWildcardTypeTest {
public class AnnotatedType类 {

    public List<? extends @MyAnnotation(1) Number > list1;

    public List<? super @MyAnnotation(2) Number> list2;

    public static void main(String[] args) {
        Arrays.stream(AnnotatedType类.class.getDeclaredFields())
                .forEach(field -> {
                    AnnotatedParameterizedType annotatedParameterizedType = (AnnotatedParameterizedType) field.getAnnotatedType();
                    print((AnnotatedWildcardType) annotatedParameterizedType.getAnnotatedActualTypeArguments()[0]);
                });
    }
    String[] iStrings= {"1","2","3"};
    
    private static void print(AnnotatedWildcardType annotatedWildcardType) {
        Arrays.stream(annotatedWildcardType.getAnnotatedUpperBounds()).forEach(annotatedType -> System.out.println(Arrays.toString(annotatedType.getDeclaredAnnotations())));
        Arrays.stream(annotatedWildcardType.getAnnotatedLowerBounds()).forEach(annotatedType -> System.out.println(Arrays.toString(annotatedType.getDeclaredAnnotations())));
    }

    @Target({ElementType.FIELD, ElementType.TYPE_USE, ElementType.TYPE, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyAnnotation {
        int value();
    }
}
//控制台输出
//
//[@com.zyc.AnnotatedWildcardTypeTest$MyAnnotation(value=1)]
//[@com.zyc.AnnotatedWildcardTypeTest$MyAnnotation(value=2)]
//在上面的例子中定义了一个AnnotatedParameterizedType类型的域，然后通过反射获取该域的WildcardType的类型参数，同样也就是AnnotatedWildcardType，然后通过AnnotatedWildcardType提供的getAnnotatedUpperBounds和getAnnotatedLowerBounds方法获取上下AnnotatedType边界，最后打印所有边界上的注解。
//
//AnnotatedArrayType
//AnnotatedArrayType是指那些可能带注解的数组类型的数据，当然啦其内部元素类型本身也可能是带注解的类型。注意AnnotatedArrayType代表的是所有数组类型（包含普通类型数组和泛型数组），而不是单指Type的子接口GenericArrayType，GenericArrayType只代表那些泛型数组。
//
//package java.lang.reflect;
//
//public interface AnnotatedArrayType extends AnnotatedType {
//
//    AnnotatedType  getAnnotatedGenericComponentType();
//}
//AnnotatedArrayType提供了一个getAnnotatedGenericComponentType方法来获取内部元素带注解的类型。下面看一个例子：
//
//
//package com.zyc;
//
//import com.zyc.AnnotatedArrayTypeTest.MyAnnotation;
//
//import java.lang.annotation.*;
//import java.lang.reflect.AnnotatedArrayType;
//import java.lang.reflect.AnnotatedParameterizedType;
//import java.lang.reflect.AnnotatedType;
//import java.lang.reflect.AnnotatedTypeVariable;
//import java.util.Arrays;
//import java.util.List;
//
///**
// * @author zyc
// */
//public class AnnotatedArrayTypeTest<T extends @MyAnnotation(8) Number> {
//
//    public @MyAnnotation(1) String @MyAnnotation(2) [] array1;
//
//    public @MyAnnotation(3) List<@MyAnnotation(4) String> @MyAnnotation(5) [] array2;
//
//    public @MyAnnotation(6) T @MyAnnotation(7) [] array3;
//	
//    // 注意二维数组第一个[]代表的是二维数组本身，第二个[]代表的是二维数组的组件本身，所以@MyAnnotation(10)
//    // 是二维数组本身上的注解，@MyAnnotation(11)是二维数组的组件本身上的注解，@MyAnnotation(9)是二维数组
//    // 组件类型上的注解
//    public @MyAnnotation(9) String @MyAnnotation(10) [] @MyAnnotation(11) [] array4;
//
//    public static void main(String[] args) {
//        Arrays.stream(AnnotatedArrayTypeTest.class.getDeclaredFields()).forEach(field -> {
//            print((AnnotatedArrayType) field.getAnnotatedType());
//        });
//    }
//
//    private static void print(AnnotatedArrayType annotatedArrayType) {
//        AnnotatedType annotatedGenericComponentType = annotatedArrayType.getAnnotatedGenericComponentType();
//        // 获取域上的注解，即[]上的注解
//        System.out.println(Arrays.toString(annotatedArrayType.getDeclaredAnnotations()));
//        // 获取组件上的注解，即数组元素类型上的注解
//        System.out.println(Arrays.toString(annotatedGenericComponentType.getDeclaredAnnotations()));
//        // 获取组件类型为AnnotatedParameterizedType的泛型参数上的注解
//        if (annotatedGenericComponentType instanceof AnnotatedParameterizedType) {
//            AnnotatedParameterizedType annotatedParameterizedType = (AnnotatedParameterizedType) annotatedGenericComponentType;
//            System.out.println(Arrays.toString(annotatedParameterizedType.getAnnotatedActualTypeArguments()[0].getDeclaredAnnotations()));
//            // 获取组件类型为AnnotatedTypeVariable的所有边界上的注解
//        } else if (annotatedGenericComponentType instanceof AnnotatedTypeVariable) {
//            AnnotatedTypeVariable annotatedTypeVariable = (AnnotatedTypeVariable) annotatedGenericComponentType;
//            Arrays.stream(annotatedTypeVariable.getAnnotatedBounds()).forEach(annotatedType -> System.out.println(Arrays.toString(annotatedType.getDeclaredAnnotations())));
//            // 递归获取组件类型为AnnotatedArrayType上的注解
//        } else if (annotatedGenericComponentType instanceof AnnotatedArrayType) {
//            print((AnnotatedArrayType) annotatedGenericComponentType);
//        }
//    }
//
//    @Target({ElementType.FIELD, ElementType.TYPE_USE, ElementType.TYPE, ElementType.PARAMETER})
//    @Retention(RetentionPolicy.RUNTIME)
//    @Documented
//    public @interface MyAnnotation {
//
//        int value();
//    }
//}
//
//控制台输出
//
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=2)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=1)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=5)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=3)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=4)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=7)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=6)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=8)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=10)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=11)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=11)]
//[@com.zyc.AnnotatedArrayTypeTest$MyAnnotation(value=9)]
//在上面的例子中分别定义了组件类型为普通类型、ParameterizedType、TypeVariable以及数组类型的四个数组，然后通过反射分别打印数组本身上的注解以及数组组件本身上的注解。在这些例子中我们需要明确注解放置的位置代表的不同含义，对于数组本身来说，放置在[]上代表的是其本身上的注解，放置在其类型定义上的注解代表的是其组件类型上的注解。
//
//AnnotatedTypeBaseImpl
//除了以上四种类型以外的类型，它们都被统一规整为AnnotatedTypeBaseImpl，这是sun.reflect.annotation包下的一个私有的内部类，当然了以上四种类型的具体实现也在这个包下，同样它们也都是私有的内部类。下面举一个简单的例子看一下什么样的类型才是AnnotatedTypeBaseImpl。
//
//
//
//package com.zyc;
//
//import java.util.Arrays;
//import java.util.List;
//
///**
// * @author zyc
// */
//public class AnnotatedTypeBaseImplTest<T> {
//
//    private String a;
//
//    private List<String> b;
//
//    private T c;
//
//    private String[] d;
//    
//    private T[] e;
//
//    public static void main(String[] args) {
//        Arrays.stream(AnnotatedTypeBaseImplTest.class.getDeclaredFields())
//                .forEach(field -> System.out.println(field.getAnnotatedType().getClass()));
//    }
//}
//控制台输出
//
//class sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedTypeBaseImpl
//class sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedParameterizedTypeImpl
//class sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedTypeVariableImpl
//class sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedArrayTypeImpl
//class sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedArrayTypeImpl
//可以看到，只要数据的Type不是ParameterizedType、TypeVariable、数组类型（包含普通数组和泛型数组）这三种类型，那么剩下的数据类型都会被规整为AnnotatedTypeBaseImpl。
//
//应用
//通过AnnotatedType能够实现很多有趣的事情。我在业余时间编写了一个数据脱敏库，通过AnnotatedType并结合反射api去分析获取那些十分复杂的数据结构中的注解从而达到数据脱敏的目的。
//
//一个简单易用的数据脱敏库
//
//总结
//AnnotatedType是jdk1.8之后新增的可能被注解的类型，根据java中的Type接口分类，程序运行时的可能被注解的元素的类型一共被划分
//为AnnotatedParameterizedType、AnnotatedTypeVariable、AnnotatedWildcardType、AnnotatedArrayType、
//AnnotatedTypeBaseImpl这五种类型。同时AnnotatedType继承了AnnotatedElement使得我们能够在运行时基于反射api去分析获取那些十分复杂的数据结构中的注解



//Java AnnotatedType类代码示例
//本文整理汇总了Java中java.lang.reflect.AnnotatedType类的典型用法代码示例。如果您正苦于以下问题：Java AnnotatedType类的具体用法？Java AnnotatedType怎么用？Java AnnotatedType使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
//
//AnnotatedType类属于java.lang.reflect包，在下文中一共展示了AnnotatedType类的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的Java代码示例。
//
//示例1: testReturnsZeroLengthArray
//​ 已点赞 4 ​您最近已经点赞过了!
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private static void testReturnsZeroLengthArray() {
//    for (Class<?> toTest : testData) {
//        tests++;
//
//        AnnotatedType[] res = toTest.getAnnotatedInterfaces();
//
//        if (res == null) {
//            failed++;
//            System.out.println(toTest + ".class.getAnnotatedInterface() returns" +
//                    "'null' should zero length array");
//        } else if (res.length != 0) {
//            failed++;
//            System.out.println(toTest + ".class.getAnnotatedInterfaces() returns: "
//                    + Arrays.asList(res) + ", should be a zero length array of AnnotatedType");
//        }
//    }
//}
// 
//开发者ID:lambdalab-mirror，项目名称:jdk8u-jdk，代码行数:18，代码来源:GetAnnotatedInterfaces.java
//
//
//
// 
//示例2: testReturnsEmptyAT
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private static void testReturnsEmptyAT() {
//    for (Class<?> toTest : nonNullTestData) {
//        tests++;
//
//        AnnotatedType res = toTest.getAnnotatedSuperclass();
//
//        if (res == null) {
//            failed++;
//            System.out.println(toTest + ".getAnnotatedSuperclass() returns 'null' should  be non-null");
//        } else if (res.getAnnotations().length != 0) {
//            failed++;
//            System.out.println(toTest + ".getAnnotatedSuperclass() returns: "
//                    + Arrays.asList(res.getAnnotations()) + ", should be an empty AnnotatedType");
//        }
//    }
//}
// 
//开发者ID:lambdalab-mirror，项目名称:jdk8u-jdk，代码行数:17，代码来源:GetAnnotatedSuperclass.java
//
//
//示例3: verifyArrayFieldTypeAnnotations
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private void verifyArrayFieldTypeAnnotations(Class c)
//    throws NoSuchFieldException, NoSuchMethodException {
//
//    Annotation anno;
//    AnnotatedType at;
//
//    at = c.getDeclaredField("typeAnnotatedArray").getAnnotatedType();
//    anno = at.getAnnotations()[0];
//    verifyTestAnn(arrayTA[0], anno, "array1");
//    arrayTA[0] = anno;
//
//    for (int i = 1; i <= 3; i++) {
//        at = ((AnnotatedArrayType) at).getAnnotatedGenericComponentType();
//        anno = at.getAnnotations()[0];
//        verifyTestAnn(arrayTA[i], anno, "array" + (i + 1));
//        arrayTA[i] = anno;
//    }
//}
// 
//开发者ID:AdoptOpenJDK，项目名称:openjdk-jdk10，代码行数:19，代码来源:RedefineAnnotations.java
//
//
//
// 
//示例4: checkNull
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private static void checkNull(Executable e, String msg) {
//    AnnotatedType a = e.getAnnotatedReceiverType();
//    if (a != null) {
//        failures++;
//        System.err.println(msg + ": " + e);
//    }
//    tests++;
//}
// 
//开发者ID:AdoptOpenJDK，项目名称:openjdk-jdk10，代码行数:9，代码来源:GetAnnotatedReceiverType.java
//
//
//示例5: getArgumentValue
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//@Override
//public Object getArgumentValue(Object rawInput, AnnotatedType type, ResolutionEnvironment resolutionEnvironment) {
//    if (GenericTypeReflector.isSuperType(setOfStrings, type.getType())) {
//        return resolutionEnvironment.dataFetchingEnvironment.getSelectionSet().get().keySet();
//    }
//    Class raw = GenericTypeReflector.erase(type.getType());
//    if (Field.class.equals(raw)) {
//        return resolutionEnvironment.fields.get(0);
//    }
//    if (GenericTypeReflector.isSuperType(listOfFields, type.getType())) {
//        return resolutionEnvironment.fields;
//    }
//    if (ValueMapper.class.isAssignableFrom(raw)) {
//        return resolutionEnvironment.valueMapper;
//    }
//    if (ResolutionEnvironment.class.isAssignableFrom(raw)) {
//        return resolutionEnvironment;
//    }
//    throw new IllegalArgumentException("Argument of type " + raw.getName() 
//            + " can not be injected via @" + GraphQLEnvironment.class.getSimpleName());
//}
// 
//开发者ID:leangen，项目名称:graphql-spqr，代码行数:22，代码来源:EnvironmentInjector.java
//
//
//
// 
//示例6: of
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
///** Create {@link JavaType} based on {@link AnnotatedType} instance. */
//public static JavaType of(AnnotatedType annotatedType) {
//  if (annotatedType instanceof AnnotatedArrayType) {
//    return JavaTypes.of((AnnotatedArrayType) annotatedType);
//  }
//  if (annotatedType instanceof AnnotatedParameterizedType) {
//    return JavaTypes.of((AnnotatedParameterizedType) annotatedType);
//  }
//  if (annotatedType instanceof AnnotatedTypeVariable) {
//    return JavaTypes.of((AnnotatedTypeVariable) annotatedType);
//  }
//  if (annotatedType instanceof AnnotatedWildcardType) {
//    return JavaTypes.of((AnnotatedWildcardType) annotatedType);
//  }
//  // default case: use underlying raw type
//  JavaType result = of(annotatedType.getType());
//  result.getAnnotations().addAll(Annotation.of(annotatedType.getAnnotations()));
//  return result;
//}
// 
//开发者ID:sormuras，项目名称:listing，代码行数:20，代码来源:JavaType.java
//
//
//示例7: of
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//public static AnnotatedType of(AnnotatedType[] types) {
//    Objects.requireNonNull(types);
//    if (types.length < 2) {
//        if (types.length == 1 && GenericTypeReflector.isSuperType(Union.class, types[0].getType())) {
//            return types[0];
//        }
//        throw new IllegalArgumentException(SINGLE_TYPE_UNION_ERROR);
//    }
//
//    AnnotatedType[] distinctTypes = dedupe(types);
//    Class union;
//    try {
//        union = ClassUtils.forName(Union.class.getName() + distinctTypes.length);
//    } catch (ClassNotFoundException e) {
//        throw new IllegalArgumentException("Unions of more than 10 types are not supported");
//    }
//    Annotation unionAnnotation = stream(ClassUtils.getAllAnnotations(stream(types)))
//            .filter(annotation -> annotation.annotationType().equals(GraphQLUnion.class))
//            .filter(annotation -> !((GraphQLUnion) annotation).description().isEmpty())
//            .findFirst().orElse(types[0].getAnnotation(GraphQLUnion.class));
//    return TypeFactory.parameterizedAnnotatedClass(union, new Annotation[] {unionAnnotation}, distinctTypes);
//}
// 
//开发者ID:leangen，项目名称:graphql-spqr，代码行数:23，代码来源:Union.java
//
//
//示例8: getInputFieldType
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private AnnotatedType getInputFieldType(AnnotatedType type, BeanPropertyDefinition propertyDefinition) {
//    AnnotatedParameter ctorParam = propertyDefinition.getConstructorParameter();
//    if (ctorParam != null) {
//        Constructor<?> constructor = (Constructor<?>) ctorParam.getOwner().getMember();
//        return ClassUtils.getParameterTypes(constructor, type)[ctorParam.getIndex()];
//    }
//    if (propertyDefinition.getSetter() != null) {
//        return ClassUtils.getParameterTypes(propertyDefinition.getSetter().getAnnotated(), type)[0];
//    }
//    if (propertyDefinition.getGetter() != null) {
//        return ClassUtils.getReturnType(propertyDefinition.getGetter().getAnnotated(), type);
//    }
//    if (propertyDefinition.getField() != null) {
//        return ClassUtils.getFieldType(propertyDefinition.getField().getAnnotated(), type);
//    }
//    throw new UnsupportedOperationException("Unknown input field mapping style encountered");
//}
// 
//开发者ID:leangen，项目名称:graphql-spqr，代码行数:18，代码来源:JacksonValueMapper.java
//
//
//示例9: collectAbstract
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//protected Set<Type> collectAbstract(AnnotatedType javaType, Set<Type> seen, BuildContext buildContext) {
//    javaType = buildContext.globalEnvironment.converters.getMappableType(javaType);
//    if (Scalars.isScalar(javaType.getType())) {
//        return Collections.emptySet();
//    }
//    if (GenericTypeReflector.isSuperType(Collection.class, javaType.getType())) {
//        AnnotatedType elementType = GenericTypeReflector.getTypeParameter(javaType, Collection.class.getTypeParameters()[0]);
//        return collectAbstractInner(elementType, seen, buildContext);
//    }
//    if (GenericTypeReflector.isSuperType(Map.class, javaType.getType())) {
//        AnnotatedType keyType = GenericTypeReflector.getTypeParameter(javaType, Map.class.getTypeParameters()[0]);
//        AnnotatedType valueType = GenericTypeReflector.getTypeParameter(javaType, Map.class.getTypeParameters()[1]);
//        Set<Type> abstractTypes = collectAbstractInner(keyType, seen, buildContext);
//        abstractTypes.addAll(collectAbstractInner(valueType, seen, buildContext));
//        return abstractTypes;
//    }
//    return collectAbstractInner(javaType, seen, buildContext);
//}
// 
//开发者ID:leangen，项目名称:graphql-spqr，代码行数:19，代码来源:AbstractionCollectingMapper.java
//
//
//示例10: collectAbstractInner
//​ 点赞 3 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private Set<Type> collectAbstractInner(AnnotatedType javaType, Set<Type> seen, BuildContext buildContext) {
//    if (buildContext.abstractComponentTypes.containsKey(javaType.getType())) {
//        return buildContext.abstractComponentTypes.get(javaType.getType());
//    }
//    if (seen.contains(javaType.getType())) {
//        return Collections.emptySet();
//    }
//    seen.add(javaType.getType());
//    Set<Type> abstractTypes = new HashSet<>();
//    if (ClassUtils.isAbstract(javaType)) {
//        abstractTypes.add(javaType.getType());
//    }
//    buildContext.inputFieldStrategy.getInputFields(javaType)
//            .forEach(childQuery -> abstractTypes.addAll(collectAbstract(childQuery.getJavaType(), seen, buildContext)));
//    buildContext.abstractComponentTypes.put(javaType.getType(), abstractTypes);
//    return abstractTypes;
//}
// 
//开发者ID:leangen，项目名称:graphql-spqr，代码行数:18，代码来源:AbstractionCollectingMapper.java
//
//
//示例11: java8TypeAnnotation
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//@Test
//public void java8TypeAnnotation() throws Exception {
//  Method method = ImmutableHasTypeAnnotation.class.getMethod("str");
//  AnnotatedType returnType = method.getAnnotatedReturnType();
//  check(returnType.getAnnotation(TypeA.class)).notNull();
//  check(returnType.getAnnotation(TypeB.class)).notNull();
//}
// 
//开发者ID:weiwenqiang，项目名称:GitHub，代码行数:8，代码来源:ValuesTest.java
//
//
//示例12: getResponsePropertySet
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
///**
// * Check whether the given <code>method</code> return type is annotated with the {@link PropertySetRef} annotation.
// * @param method Method to inspect
// * @return Optional {@link PropertySetRef} annotation, if available
// */
//private static Optional<PropertySetRef> getResponsePropertySet(Method method) {
//    final AnnotatedType rt = method.getAnnotatedReturnType();
//    if (rt != null) {
//        if (rt.isAnnotationPresent(PropertySetRef.class)) {
//            return Optional.of(rt.getAnnotation(PropertySetRef.class));
//        }
//        // check meta-annotations
//        List<PropertySetRef> annotations = AnnotationUtils.getAnnotations(rt, PropertySetRef.class);
//        if (!annotations.isEmpty()) {
//            return Optional.ofNullable(annotations.get(0));
//        }
//    }
//    return Optional.empty();
//}
// 
//开发者ID:holon-platform，项目名称:holon-jaxrs，代码行数:20，代码来源:PropertyBoxSwaggerExtension.java
//
//
//示例13: getResponsePropertySetModel
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
///**
// * Check whether the given <code>method</code> return type is annotated with the {@link ApiPropertySetModel}
// * annotation.
// * @param method Method to inspect
// * @return Optional {@link ApiPropertySetModel} annotation, if available
// */
//private static Optional<ApiPropertySetModel> getResponsePropertySetModel(Method method) {
//    final AnnotatedType rt = method.getAnnotatedReturnType();
//    if (rt != null) {
//        if (rt.isAnnotationPresent(ApiPropertySetModel.class)) {
//            return Optional.of(rt.getAnnotation(ApiPropertySetModel.class));
//        }
//        // check meta-annotations
//        List<ApiPropertySetModel> annotations = AnnotationUtils.getAnnotations(rt, ApiPropertySetModel.class);
//        if (!annotations.isEmpty()) {
//            return Optional.ofNullable(annotations.get(0));
//        }
//    }
//    return Optional.empty();
//}
// 
//开发者ID:holon-platform，项目名称:holon-jaxrs，代码行数:21，代码来源:PropertyBoxSwaggerExtension.java
//
//
//示例14: MinijaxPropertyDescriptor
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//public MinijaxPropertyDescriptor(final Class<?> elementClass, final AnnotatedType annotatedType, final Annotation[] annotations) {
//    super(elementClass, buildConstraintDescriptors(annotatedType, annotations));
//
//    if (annotatedType instanceof AnnotatedParameterizedType) {
//        constrainedContainerElementTypes = MinijaxContainerElementTypeDescriptor.build(elementClass, (AnnotatedParameterizedType) annotatedType);
//    } else {
//        constrainedContainerElementTypes = emptySet();
//    }
//}
// 
//开发者ID:minijax，项目名称:minijax，代码行数:10，代码来源:MinijaxPropertyDescriptor.java
//
//
//示例15: buildConstraintDescriptors
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private static Set<ConstraintDescriptor<?>> buildConstraintDescriptors(final AnnotatedType annotatedType, final Annotation[] annotations) {
//    final Set<ConstraintDescriptor<?>> result = new HashSet<>();
//
//    for (final Annotation annotation : annotations) {
//        final MinijaxConstraintDescriptor<?> constraintDescriptor = MinijaxConstraintDescriptor.build(annotatedType, annotation);
//        if (constraintDescriptor != null) {
//            result.add(constraintDescriptor);
//        }
//    }
//
//    return result;
//}
// 
//开发者ID:minijax，项目名称:minijax，代码行数:13，代码来源:MinijaxPropertyDescriptor.java
//
//
//示例16: build
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//public static Set<ContainerElementTypeDescriptor> build(
//        final Class<?> elementClass,
//        final AnnotatedParameterizedType annotatedType) {
//
//    final Set<ContainerElementTypeDescriptor> result = new HashSet<>();
//    final Class<?> containerClass = ReflectionUtils.getRawType(annotatedType);
//    int argIndex = 0;
//
//    for (final AnnotatedType typeArg : annotatedType.getAnnotatedActualTypeArguments()) {
//        final Set<ConstraintDescriptor<?>> constraintDescriptors = new HashSet<>();
//
//        for (final Annotation annotation : typeArg.getAnnotations()) {
//            final MinijaxConstraintDescriptor<?> constraintDescriptor = MinijaxConstraintDescriptor.build(typeArg, annotation);
//            if (constraintDescriptor != null) {
//                constraintDescriptors.add(constraintDescriptor);
//            }
//        }
//
//        if (!constraintDescriptors.isEmpty()) {
//            result.add(new MinijaxContainerElementTypeDescriptor(elementClass, containerClass, argIndex, constraintDescriptors));
//        }
//
//        argIndex++;
//    }
//
//    return result;
//}
// 
//开发者ID:minijax，项目名称:minijax，代码行数:28，代码来源:MinijaxContainerElementTypeDescriptor.java
//
//
//示例17: getRawType
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//public static Class<?> getRawType(final AnnotatedType annotatedType) {
//    final Type containerType = annotatedType.getType();
//    if (containerType instanceof Class) {
//        return (Class<?>) containerType;
//    } else if (containerType instanceof ParameterizedType) {
//        return (Class<?>) ((ParameterizedType) containerType).getRawType();
//    } else {
//        throw new ValidationException("Unknown type: " + containerType.getClass());
//    }
//}
// 
//开发者ID:minijax，项目名称:minijax，代码行数:11，代码来源:ReflectionUtils.java
//
//
//示例18: checkEmptyAT
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private static void checkEmptyAT(AnnotatedType a, String msg) {
//    if (a.getAnnotations().length != 0) {
//        failures++;
//        System.err.print(msg);
//    }
//    tests++;
//}
// 
//开发者ID:lambdalab-mirror，项目名称:jdk8u-jdk，代码行数:8，代码来源:GetAnnotatedReceiverType.java
//
//
//示例19: verifyInnerFieldTypeAnnotations
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private void verifyInnerFieldTypeAnnotations(Class c)
//    throws NoSuchFieldException, NoSuchMethodException {
//
//    AnnotatedType at = c.getDeclaredField("typeAnnotatedInner").getAnnotatedType();
//    Annotation anno = at.getAnnotations()[0];
//    verifyTestAnn(innerTA, anno, "inner");
//    innerTA = anno;
//}
// 
//开发者ID:AdoptOpenJDK，项目名称:openjdk-jdk10，代码行数:9，代码来源:RedefineAnnotations.java
//
//
//示例20: verifyMapFieldTypeAnnotations
//​ 点赞 2 ​
//import java.lang.reflect.AnnotatedType; //导入依赖的package包/类
//private void verifyMapFieldTypeAnnotations(Class c)
//    throws NoSuchFieldException, NoSuchMethodException {
//
//    Annotation anno;
//    AnnotatedType atBase;
//    AnnotatedType atParameter;
//    atBase = c.getDeclaredField("typeAnnotatedMap").getAnnotatedType();
//
//    anno = atBase.getAnnotations()[0];
//    verifyTestAnn(mapTA[0], anno, "map1");
//    mapTA[0] = anno;
//
//    atParameter =
//        ((AnnotatedParameterizedType) atBase).
//        getAnnotatedActualTypeArguments()[0];
//    anno = ((AnnotatedWildcardType) atParameter).getAnnotations()[0];
//    verifyTestAnn(mapTA[1], anno, "map2");
//    mapTA[1] = anno;
//
//    anno =
//        ((AnnotatedWildcardType) atParameter).
//        getAnnotatedUpperBounds()[0].getAnnotations()[0];
//    verifyTestAnn(mapTA[2], anno, "map3");
//    mapTA[2] = anno;
//
//    atParameter =
//        ((AnnotatedParameterizedType) atBase).
//        getAnnotatedActualTypeArguments()[1];
//    anno = ((AnnotatedParameterizedType) atParameter).getAnnotations()[0];
//    verifyTestAnn(mapTA[3], anno, "map4");
//    mapTA[3] = anno;
//
//    anno =
//        ((AnnotatedParameterizedType) atParameter).
//        getAnnotatedActualTypeArguments()[0].getAnnotations()[0];
//    verifyTestAnn(mapTA[4], anno, "map5");
//    mapTA[4] = anno;
//}
// 
//开发者ID:AdoptOpenJDK，项目名称:openjdk-jdk10，代码行数:39，代码来源:RedefineAnnotations.java
//
//
//
//注：本文中的java.lang.reflect.AnnotatedType类示例整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源
//项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。
